home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_unicode.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  25KB  |  599 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. ''' Test script for the Unicode implementation.
  5.  
  6. Written by Marc-Andre Lemburg (mal@lemburg.com).
  7.  
  8. (c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
  9.  
  10. '''
  11. import unittest
  12. import sys
  13. import string
  14. import codecs
  15. import new
  16. from test import test_support, string_tests
  17.  
  18. class UnicodeTest(string_tests.CommonTest, string_tests.MixinStrUnicodeUserStringTest, string_tests.MixinStrUnicodeTest):
  19.     type2test = unicode
  20.     
  21.     def checkequalnofix(self, result, object, methodname, *args):
  22.         method = getattr(object, methodname)
  23.         realresult = method(*args)
  24.         self.assertEqual(realresult, result)
  25.         self.assert_(type(realresult) is type(result))
  26.         if realresult is object:
  27.             
  28.             class usub(unicode):
  29.                 
  30.                 def __repr__(self):
  31.                     return 'usub(%r)' % unicode.__repr__(self)
  32.  
  33.  
  34.             object = usub(object)
  35.             method = getattr(object, methodname)
  36.             realresult = method(*args)
  37.             self.assertEqual(realresult, result)
  38.             self.assert_(object is not realresult)
  39.         
  40.  
  41.     
  42.     def test_literals(self):
  43.         self.assertEqual(u'\xc3\xbf', u'\xc3\xbf')
  44.         self.assertEqual(u'\xef\xbf\xbf', u'\xef\xbf\xbf')
  45.         self.assertRaises(UnicodeError, eval, "u'\\Ufffffffe'")
  46.         self.assertRaises(UnicodeError, eval, "u'\\Uffffffff'")
  47.         self.assertRaises(UnicodeError, eval, "u'\\U%08x'" % 1114112)
  48.  
  49.     
  50.     def test_repr(self):
  51.         if not sys.platform.startswith('java'):
  52.             self.assertEqual(repr(u'abc'), "u'abc'")
  53.             self.assertEqual(repr(u'ab\\c'), "u'ab\\\\c'")
  54.             self.assertEqual(repr(u'ab\\'), "u'ab\\\\'")
  55.             self.assertEqual(repr(u'\\c'), "u'\\\\c'")
  56.             self.assertEqual(repr(u'\\'), "u'\\\\'")
  57.             self.assertEqual(repr(u'\n'), "u'\\n'")
  58.             self.assertEqual(repr(u'\r'), "u'\\r'")
  59.             self.assertEqual(repr(u'\t'), "u'\\t'")
  60.             self.assertEqual(repr(u'\x08'), "u'\\x08'")
  61.             self.assertEqual(repr(u'\'"'), 'u\'\\\'"\'')
  62.             self.assertEqual(repr(u'\'"'), 'u\'\\\'"\'')
  63.             self.assertEqual(repr(u"'"), 'u"\'"')
  64.             self.assertEqual(repr(u'"'), 'u\'"\'')
  65.             latin1repr = 'u\'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f !"#$%&\\\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b\\x9c\\x9d\\x9e\\x9f\\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\\xa8\\xa9\\xaa\\xab\\xac\\xad\\xae\\xaf\\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7\\xb8\\xb9\\xba\\xbb\\xbc\\xbd\\xbe\\xbf\\xc0\\xc1\\xc2\\xc3\\xc4\\xc5\\xc6\\xc7\\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\\xd0\\xd1\\xd2\\xd3\\xd4\\xd5\\xd6\\xd7\\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\\xe0\\xe1\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd\\xfe\\xff\''
  66.             testrepr = repr(u''.join(map(unichr, xrange(256))))
  67.             self.assertEqual(testrepr, latin1repr)
  68.         
  69.  
  70.     
  71.     def test_count(self):
  72.         string_tests.CommonTest.test_count(self)
  73.         self.checkequalnofix(3, 'aaa', 'count', u'a')
  74.         self.checkequalnofix(0, 'aaa', 'count', u'b')
  75.         self.checkequalnofix(3, u'aaa', 'count', 'a')
  76.         self.checkequalnofix(0, u'aaa', 'count', 'b')
  77.         self.checkequalnofix(0, u'aaa', 'count', 'b')
  78.         self.checkequalnofix(1, u'aaa', 'count', 'a', -1)
  79.         self.checkequalnofix(3, u'aaa', 'count', 'a', -10)
  80.         self.checkequalnofix(2, u'aaa', 'count', 'a', 0, -1)
  81.         self.checkequalnofix(0, u'aaa', 'count', 'a', 0, -10)
  82.  
  83.     
  84.     def test_find(self):
  85.         self.checkequalnofix(0, u'abcdefghiabc', 'find', u'abc')
  86.         self.checkequalnofix(9, u'abcdefghiabc', 'find', u'abc', 1)
  87.         self.checkequalnofix(-1, u'abcdefghiabc', 'find', u'def', 4)
  88.         self.assertRaises(TypeError, u'hello'.find)
  89.         self.assertRaises(TypeError, u'hello'.find, 42)
  90.  
  91.     
  92.     def test_rfind(self):
  93.         string_tests.CommonTest.test_rfind(self)
  94.         self.checkequalnofix(9, 'abcdefghiabc', 'rfind', u'abc')
  95.         self.checkequalnofix(12, 'abcdefghiabc', 'rfind', u'')
  96.         self.checkequalnofix(12, u'abcdefghiabc', 'rfind', '')
  97.  
  98.     
  99.     def test_index(self):
  100.         string_tests.CommonTest.test_index(self)
  101.         for t1, t2 in ((str, unicode), (unicode, str)):
  102.             self.checkequalnofix(0, t1('abcdefghiabc'), 'index', t2(''))
  103.             self.checkequalnofix(3, t1('abcdefghiabc'), 'index', t2('def'))
  104.             self.checkequalnofix(0, t1('abcdefghiabc'), 'index', t2('abc'))
  105.             self.checkequalnofix(9, t1('abcdefghiabc'), 'index', t2('abc'), 1)
  106.             self.assertRaises(ValueError, t1('abcdefghiabc').index, t2('hib'))
  107.             self.assertRaises(ValueError, t1('abcdefghiab').index, t2('abc'), 1)
  108.             self.assertRaises(ValueError, t1('abcdefghi').index, t2('ghi'), 8)
  109.             self.assertRaises(ValueError, t1('abcdefghi').index, t2('ghi'), -1)
  110.         
  111.  
  112.     
  113.     def test_rindex(self):
  114.         string_tests.CommonTest.test_rindex(self)
  115.         for t1, t2 in ((str, unicode), (unicode, str)):
  116.             self.checkequalnofix(12, t1('abcdefghiabc'), 'rindex', t2(''))
  117.             self.checkequalnofix(3, t1('abcdefghiabc'), 'rindex', t2('def'))
  118.             self.checkequalnofix(9, t1('abcdefghiabc'), 'rindex', t2('abc'))
  119.             self.checkequalnofix(0, t1('abcdefghiabc'), 'rindex', t2('abc'), 0, -1)
  120.             self.assertRaises(ValueError, t1('abcdefghiabc').rindex, t2('hib'))
  121.             self.assertRaises(ValueError, t1('defghiabc').rindex, t2('def'), 1)
  122.             self.assertRaises(ValueError, t1('defghiabc').rindex, t2('abc'), 0, -1)
  123.             self.assertRaises(ValueError, t1('abcdefghi').rindex, t2('ghi'), 0, 8)
  124.             self.assertRaises(ValueError, t1('abcdefghi').rindex, t2('ghi'), 0, -1)
  125.         
  126.  
  127.     
  128.     def test_translate(self):
  129.         self.checkequalnofix(u'bbbc', u'abababc', 'translate', {
  130.             ord('a'): None })
  131.         self.checkequalnofix(u'iiic', u'abababc', 'translate', {
  132.             ord('a'): None,
  133.             ord('b'): ord('i') })
  134.         self.checkequalnofix(u'iiix', u'abababc', 'translate', {
  135.             ord('a'): None,
  136.             ord('b'): ord('i'),
  137.             ord('c'): u'x' })
  138.         self.checkequalnofix(u'<i><i><i>c', u'abababc', 'translate', {
  139.             ord('a'): None,
  140.             ord('b'): u'<i>' })
  141.         self.checkequalnofix(u'c', u'abababc', 'translate', {
  142.             ord('a'): None,
  143.             ord('b'): u'' })
  144.         self.checkequalnofix(u'xyyx', u'xzx', 'translate', {
  145.             ord('z'): u'yy' })
  146.         self.assertRaises(TypeError, u'hello'.translate)
  147.         self.assertRaises(TypeError, u'abababc'.translate, {
  148.             ord('a'): '' })
  149.  
  150.     
  151.     def test_split(self):
  152.         string_tests.CommonTest.test_split(self)
  153.         self.checkequalnofix([
  154.             u'a',
  155.             u'b',
  156.             u'c',
  157.             u'd'], u'a//b//c//d', 'split', '//')
  158.         self.checkequalnofix([
  159.             u'a',
  160.             u'b',
  161.             u'c',
  162.             u'd'], 'a//b//c//d', 'split', u'//')
  163.         self.checkequalnofix([
  164.             u'endcase ',
  165.             u''], u'endcase test', 'split', 'test')
  166.  
  167.     
  168.     def test_join(self):
  169.         string_tests.MixinStrUnicodeUserStringTest.test_join(self)
  170.         self.checkequalnofix(u'a b c d', u' ', 'join', [
  171.             'a',
  172.             'b',
  173.             u'c',
  174.             u'd'])
  175.         self.checkequalnofix(u'abcd', u'', 'join', (u'a', u'b', u'c', u'd'))
  176.         self.checkequalnofix(u'w x y z', u' ', 'join', string_tests.Sequence('wxyz'))
  177.         self.checkequalnofix(u'a b c d', ' ', 'join', [
  178.             u'a',
  179.             u'b',
  180.             u'c',
  181.             u'd'])
  182.         self.checkequalnofix(u'a b c d', ' ', 'join', [
  183.             'a',
  184.             'b',
  185.             u'c',
  186.             u'd'])
  187.         self.checkequalnofix(u'abcd', '', 'join', (u'a', u'b', u'c', u'd'))
  188.         self.checkequalnofix(u'w x y z', ' ', 'join', string_tests.Sequence(u'wxyz'))
  189.  
  190.     
  191.     def test_strip(self):
  192.         string_tests.CommonTest.test_strip(self)
  193.         self.assertRaises(UnicodeError, u'hello'.strip, '\xff')
  194.  
  195.     
  196.     def test_replace(self):
  197.         string_tests.CommonTest.test_replace(self)
  198.         self.checkequalnofix(u'one@two!three!', 'one!two!three!', 'replace', u'!', u'@', 1)
  199.         self.assertRaises(TypeError, 'replace'.replace, u'r', 42)
  200.  
  201.     
  202.     def test_comparison(self):
  203.         self.assertEqual(u'abc', 'abc')
  204.         self.assertEqual('abc', u'abc')
  205.         self.assertEqual(u'abc', u'abc')
  206.         self.assert_(u'abcd' > 'abc')
  207.         self.assert_('abcd' > u'abc')
  208.         self.assert_(u'abcd' > u'abc')
  209.         self.assert_(u'abc' < 'abcd')
  210.         self.assert_('abc' < u'abcd')
  211.         self.assert_(u'abc' < u'abcd')
  212.         self.assert_(u'\xf0\x90\x80\x82' < u'\xf0\xa3\x91\x96')
  213.  
  214.     
  215.     def test_islower(self):
  216.         string_tests.MixinStrUnicodeUserStringTest.test_islower(self)
  217.         self.checkequalnofix(False, u'\xe1\xbf\xbc', 'islower')
  218.  
  219.     
  220.     def test_isupper(self):
  221.         string_tests.MixinStrUnicodeUserStringTest.test_isupper(self)
  222.         if not sys.platform.startswith('java'):
  223.             self.checkequalnofix(False, u'\xe1\xbf\xbc', 'isupper')
  224.         
  225.  
  226.     
  227.     def test_istitle(self):
  228.         string_tests.MixinStrUnicodeUserStringTest.test_title(self)
  229.         self.checkequalnofix(True, u'\xe1\xbf\xbc', 'istitle')
  230.         self.checkequalnofix(True, u'Greek \xe1\xbf\xbcitlecases ...', 'istitle')
  231.  
  232.     
  233.     def test_isspace(self):
  234.         string_tests.MixinStrUnicodeUserStringTest.test_isspace(self)
  235.         self.checkequalnofix(True, u'\xe2\x80\x80', 'isspace')
  236.         self.checkequalnofix(True, u'\xe2\x80\x8a', 'isspace')
  237.         self.checkequalnofix(False, u'\xe2\x80\x94', 'isspace')
  238.  
  239.     
  240.     def test_isalpha(self):
  241.         string_tests.MixinStrUnicodeUserStringTest.test_isalpha(self)
  242.         self.checkequalnofix(True, u'\xe1\xbf\xbc', 'isalpha')
  243.  
  244.     
  245.     def test_isdecimal(self):
  246.         self.checkequalnofix(False, u'', 'isdecimal')
  247.         self.checkequalnofix(False, u'a', 'isdecimal')
  248.         self.checkequalnofix(True, u'0', 'isdecimal')
  249.         self.checkequalnofix(False, u'\xe2\x91\xa0', 'isdecimal')
  250.         self.checkequalnofix(False, u'\xc2\xbc', 'isdecimal')
  251.         self.checkequalnofix(True, u'\xd9\xa0', 'isdecimal')
  252.         self.checkequalnofix(True, u'0123456789', 'isdecimal')
  253.         self.checkequalnofix(False, u'0123456789a', 'isdecimal')
  254.         self.checkraises(TypeError, 'abc', 'isdecimal', 42)
  255.  
  256.     
  257.     def test_isdigit(self):
  258.         string_tests.MixinStrUnicodeUserStringTest.test_isdigit(self)
  259.         self.checkequalnofix(True, u'\xe2\x91\xa0', 'isdigit')
  260.         self.checkequalnofix(False, u'\xc2\xbc', 'isdigit')
  261.         self.checkequalnofix(True, u'\xd9\xa0', 'isdigit')
  262.  
  263.     
  264.     def test_isnumeric(self):
  265.         self.checkequalnofix(False, u'', 'isnumeric')
  266.         self.checkequalnofix(False, u'a', 'isnumeric')
  267.         self.checkequalnofix(True, u'0', 'isnumeric')
  268.         self.checkequalnofix(True, u'\xe2\x91\xa0', 'isnumeric')
  269.         self.checkequalnofix(True, u'\xc2\xbc', 'isnumeric')
  270.         self.checkequalnofix(True, u'\xd9\xa0', 'isnumeric')
  271.         self.checkequalnofix(True, u'0123456789', 'isnumeric')
  272.         self.checkequalnofix(False, u'0123456789a', 'isnumeric')
  273.         self.assertRaises(TypeError, u'abc'.isnumeric, 42)
  274.  
  275.     
  276.     def test_contains(self):
  277.         self.assert_('a' in u'abdb')
  278.         self.assert_('a' in u'bdab')
  279.         self.assert_('a' in u'bdaba')
  280.         self.assert_('a' in u'bdba')
  281.         self.assert_('a' in u'bdba')
  282.         self.assert_(u'a' in u'bdba')
  283.         self.assert_(u'a' not in u'bdb')
  284.         self.assert_(u'a' not in 'bdb')
  285.         self.assert_(u'a' in 'bdba')
  286.         self.assert_(u'a' in ('a', 1, None))
  287.         self.assert_(u'a' in (1, None, 'a'))
  288.         self.assert_(u'a' in (1, None, u'a'))
  289.         self.assert_('a' in ('a', 1, None))
  290.         self.assert_('a' in (1, None, 'a'))
  291.         self.assert_('a' in (1, None, u'a'))
  292.         self.assert_('a' not in ('x', 1, u'y'))
  293.         self.assert_('a' not in ('x', 1, None))
  294.         self.assert_(u'abcd' not in u'abcxxxx')
  295.         self.assert_(u'ab' in u'abcd')
  296.         self.assert_('ab' in u'abc')
  297.         self.assert_(u'ab' in 'abc')
  298.         self.assert_(u'ab' in (1, None, u'ab'))
  299.         self.assert_(u'' in u'abc')
  300.         self.assert_('' in u'abc')
  301.         self.assertRaises(UnicodeError, 'g\xe2teau'.__contains__, u'\xc3\xa2')
  302.         self.assert_(u'' in '')
  303.         self.assert_('' in u'')
  304.         self.assert_(u'' in u'')
  305.         self.assert_(u'' in 'abc')
  306.         self.assert_('' in u'abc')
  307.         self.assert_(u'' in u'abc')
  308.         self.assert_(u'\x00' not in 'abc')
  309.         self.assert_('\x00' not in u'abc')
  310.         self.assert_(u'\x00' not in u'abc')
  311.         self.assert_(u'\x00' in '\x00abc')
  312.         self.assert_('\x00' in u'\x00abc')
  313.         self.assert_(u'\x00' in u'\x00abc')
  314.         self.assert_(u'\x00' in 'abc\x00')
  315.         self.assert_('\x00' in u'abc\x00')
  316.         self.assert_(u'\x00' in u'abc\x00')
  317.         self.assert_(u'a' in '\x00abc')
  318.         self.assert_('a' in u'\x00abc')
  319.         self.assert_(u'a' in u'\x00abc')
  320.         self.assert_(u'asdf' in 'asdf')
  321.         self.assert_('asdf' in u'asdf')
  322.         self.assert_(u'asdf' in u'asdf')
  323.         self.assert_(u'asdf' not in 'asd')
  324.         self.assert_('asdf' not in u'asd')
  325.         self.assert_(u'asdf' not in u'asd')
  326.         self.assert_(u'asdf' not in '')
  327.         self.assert_('asdf' not in u'')
  328.         self.assert_(u'asdf' not in u'')
  329.         self.assertRaises(TypeError, u'abc'.__contains__)
  330.  
  331.     
  332.     def test_formatting(self):
  333.         string_tests.MixinStrUnicodeUserStringTest.test_formatting(self)
  334.         self.assertEqual(u'%s, %s' % (u'abc', 'abc'), u'abc, abc')
  335.         self.assertEqual(u'%s, %s, %i, %f, %5.2f' % (u'abc', 'abc', 1, 2, 3), u'abc, abc, 1, 2.000000,  3.00')
  336.         self.assertEqual(u'%s, %s, %i, %f, %5.2f' % (u'abc', 'abc', 1, -2, 3), u'abc, abc, 1, -2.000000,  3.00')
  337.         self.assertEqual(u'%s, %s, %i, %f, %5.2f' % (u'abc', 'abc', -1, -2, 3.5), u'abc, abc, -1, -2.000000,  3.50')
  338.         self.assertEqual(u'%s, %s, %i, %f, %5.2f' % (u'abc', 'abc', -1, -2, 3.5699999999999998), u'abc, abc, -1, -2.000000,  3.57')
  339.         self.assertEqual(u'%s, %s, %i, %f, %5.2f' % (u'abc', 'abc', -1, -2, 1003.5700000000001), u'abc, abc, -1, -2.000000, 1003.57')
  340.         if not sys.platform.startswith('java'):
  341.             self.assertEqual(u'%r, %r' % (u'abc', 'abc'), u"u'abc', 'abc'")
  342.         
  343.         self.assertEqual(u'%(x)s, %(y)s' % {
  344.             'x': u'abc',
  345.             'y': 'def' }, u'abc, def')
  346.         self.assertEqual(u'%(x)s, %(\xc3\xbc)s' % {
  347.             'x': u'abc',
  348.             u'\xc3\xbc': 'def' }, u'abc, def')
  349.         self.assertEqual(u'%c' % 4660, u'\xe1\x88\xb4')
  350.         self.assertRaises(OverflowError, u'%c'.__mod__, (sys.maxunicode + 1,))
  351.         self.assertEqual('...%(foo)s...' % {
  352.             'foo': u'abc' }, u'...abc...')
  353.         self.assertEqual('...%(foo)s...' % {
  354.             'foo': 'abc' }, '...abc...')
  355.         self.assertEqual('...%(foo)s...' % {
  356.             u'foo': 'abc' }, '...abc...')
  357.         self.assertEqual('...%(foo)s...' % {
  358.             u'foo': u'abc' }, u'...abc...')
  359.         self.assertEqual('...%(foo)s...' % {
  360.             u'foo': u'abc',
  361.             'def': 123 }, u'...abc...')
  362.         self.assertEqual('...%(foo)s...' % {
  363.             u'foo': u'abc',
  364.             u'def': 123 }, u'...abc...')
  365.         self.assertEqual('...%s...%s...%s...%s...' % (1, 2, 3, u'abc'), u'...1...2...3...abc...')
  366.         self.assertEqual('...%%...%%s...%s...%s...%s...%s...' % (1, 2, 3, u'abc'), u'...%...%s...1...2...3...abc...')
  367.         self.assertEqual('...%s...' % u'abc', u'...abc...')
  368.         self.assertEqual('%*s' % (5, u'abc'), u'  abc')
  369.         self.assertEqual('%*s' % (-5, u'abc'), u'abc  ')
  370.         self.assertEqual('%*.*s' % (5, 2, u'abc'), u'   ab')
  371.         self.assertEqual('%*.*s' % (5, 3, u'abc'), u'  abc')
  372.         self.assertEqual('%i %*.*s' % (10, 5, 3, u'abc'), u'10   abc')
  373.         self.assertEqual('%i%s %*.*s' % (10, 3, 5, 3, u'abc'), u'103   abc')
  374.         self.assertEqual('%c' % u'a', u'a')
  375.  
  376.     
  377.     def test_constructor(self):
  378.         self.assertEqual(unicode(u'unicode remains unicode'), u'unicode remains unicode')
  379.         
  380.         class UnicodeSubclass(unicode):
  381.             pass
  382.  
  383.         self.assertEqual(unicode(UnicodeSubclass('unicode subclass becomes unicode')), u'unicode subclass becomes unicode')
  384.         self.assertEqual(unicode('strings are converted to unicode'), u'strings are converted to unicode')
  385.         
  386.         class UnicodeCompat:
  387.             
  388.             def __init__(self, x):
  389.                 self.x = x
  390.  
  391.             
  392.             def __unicode__(self):
  393.                 return self.x
  394.  
  395.  
  396.         self.assertEqual(unicode(UnicodeCompat('__unicode__ compatible objects are recognized')), u'__unicode__ compatible objects are recognized')
  397.         
  398.         class StringCompat:
  399.             
  400.             def __init__(self, x):
  401.                 self.x = x
  402.  
  403.             
  404.             def __str__(self):
  405.                 return self.x
  406.  
  407.  
  408.         self.assertEqual(unicode(StringCompat('__str__ compatible objects are recognized')), u'__str__ compatible objects are recognized')
  409.         o = StringCompat('unicode(obj) is compatible to str()')
  410.         self.assertEqual(unicode(o), u'unicode(obj) is compatible to str()')
  411.         self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
  412.         self.assertEqual(u'%s' % UnicodeCompat(u"u'%s' % obj uses obj.__unicode__()"), u"u'%s' % obj uses obj.__unicode__()")
  413.         self.assertEqual(u'%s' % UnicodeCompat(u"u'%s' % obj falls back to obj.__str__()"), u"u'%s' % obj falls back to obj.__str__()")
  414.         for obj in (123, 123.45, 0x7BL):
  415.             self.assertEqual(unicode(obj), unicode(str(obj)))
  416.         
  417.         if not sys.platform.startswith('java'):
  418.             self.assertRaises(TypeError, unicode, u'decoding unicode is not supported', 'utf-8', 'strict')
  419.         
  420.         self.assertEqual(unicode('strings are decoded to unicode', 'utf-8', 'strict'), u'strings are decoded to unicode')
  421.         if not sys.platform.startswith('java'):
  422.             self.assertEqual(unicode(buffer('character buffers are decoded to unicode'), 'utf-8', 'strict'), u'character buffers are decoded to unicode')
  423.         
  424.         self.assertRaises(TypeError, unicode, 42, 42, 42)
  425.  
  426.     
  427.     def test_codecs_utf7(self):
  428.         utfTests = [
  429.             (u'A\xe2\x89\xa2\xce\x91.', 'A+ImIDkQ.'),
  430.             (u'Hi Mom -\xe2\x98\xba-!', 'Hi Mom -+Jjo--!'),
  431.             (u'\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e', '+ZeVnLIqe-'),
  432.             (u'Item 3 is \xc2\xa31.', 'Item 3 is +AKM-1.'),
  433.             (u'+', '+-'),
  434.             (u'+-', '+--'),
  435.             (u'+?', '+-?'),
  436.             (u'\\?', '+AFw?'),
  437.             (u'+?', '+-?'),
  438.             (u'\\\\?', '+AFwAXA?'),
  439.             (u'\\\\\\?', '+AFwAXABc?'),
  440.             (u'++--', '+-+---')]
  441.         for x, y in utfTests:
  442.             self.assertEqual(x.encode('utf-7'), y)
  443.         
  444.         self.assertRaises(UnicodeError, unicode, '+3ADYAA-', 'utf-7')
  445.         self.assertEqual(unicode('+3ADYAA-', 'utf-7', 'replace'), u'\xef\xbf\xbd')
  446.  
  447.     
  448.     def test_codecs_utf8(self):
  449.         self.assertEqual(u''.encode('utf-8'), '')
  450.         self.assertEqual(u'\xe2\x82\xac'.encode('utf-8'), '\xe2\x82\xac')
  451.         self.assertEqual(u'\xf0\x90\x80\x82'.encode('utf-8'), '\xf0\x90\x80\x82')
  452.         self.assertEqual(u'\xf0\xa3\x91\x96'.encode('utf-8'), '\xf0\xa3\x91\x96')
  453.         self.assertEqual(u'\xed\xa0\x80'.encode('utf-8'), '\xed\xa0\x80')
  454.         self.assertEqual(u'\xed\xb0\x80'.encode('utf-8'), '\xed\xb0\x80')
  455.         self.assertEqual((u'\xf0\x90\x80\x82' * 1000).encode('utf-8'), '\xf0\x90\x80\x82' * 1000)
  456.         self.assertEqual(u'\xe6\xad\xa3\xe7\xa2\xba\xe3\x81\xab\xe8\xa8\x80\xe3\x81\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3\xe3\x81\xaf\xe3\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3\x81\xbe\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8\xaa\x9e\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81\xe3\x81\x82\xe3\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81\x9f\xe3\x82\x89\xe3\x82\x81\xe3\x81\xa7\xe3\x81\x99\xe3\x80\x82\xe5\xae\x9f\xe9\x9a\x9b\xe3\x81\xab\xe3\x81\xaf\xe3\x80\x8cWenn ist das Nunstuck git und'.encode('utf-8'), '\xe6\xad\xa3\xe7\xa2\xba\xe3\x81\xab\xe8\xa8\x80\xe3\x81\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3\xe3\x81\xaf\xe3\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3\x81\xbe\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8\xaa\x9e\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81\xe3\x81\x82\xe3\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81\x9f\xe3\x82\x89\xe3\x82\x81\xe3\x81\xa7\xe3\x81\x99\xe3\x80\x82\xe5\xae\x9f\xe9\x9a\x9b\xe3\x81\xab\xe3\x81\xaf\xe3\x80\x8cWenn ist das Nunstuck git und')
  457.         self.assertEqual(unicode('\xf0\xa3\x91\x96', 'utf-8'), u'\xf0\xa3\x91\x96')
  458.         self.assertEqual(unicode('\xf0\x90\x80\x82', 'utf-8'), u'\xf0\x90\x80\x82')
  459.         self.assertEqual(unicode('\xe2\x82\xac', 'utf-8'), u'\xe2\x82\xac')
  460.  
  461.     
  462.     def test_codecs_idna(self):
  463.         self.assertEqual(u'www.python.org.'.encode('idna'), 'www.python.org.')
  464.  
  465.     
  466.     def test_codecs_errors(self):
  467.         self.assertRaises(UnicodeError, u'Andr\xc2\x82 x'.encode, 'ascii')
  468.         self.assertRaises(UnicodeError, u'Andr\xc2\x82 x'.encode, 'ascii', 'strict')
  469.         self.assertEqual(u'Andr\xc2\x82 x'.encode('ascii', 'ignore'), 'Andr x')
  470.         self.assertEqual(u'Andr\xc2\x82 x'.encode('ascii', 'replace'), 'Andr? x')
  471.         self.assertRaises(UnicodeError, unicode, 'Andr\x82 x', 'ascii')
  472.         self.assertRaises(UnicodeError, unicode, 'Andr\x82 x', 'ascii', 'strict')
  473.         self.assertEqual(unicode('Andr\x82 x', 'ascii', 'ignore'), u'Andr x')
  474.         self.assertEqual(unicode('Andr\x82 x', 'ascii', 'replace'), u'Andr\xef\xbf\xbd x')
  475.         self.assertEqual('\\N{foo}xx'.decode('unicode-escape', 'ignore'), u'xx')
  476.         self.assertRaises(UnicodeError, '\\'.decode, 'unicode-escape')
  477.         
  478.         def search_function(encoding):
  479.             
  480.             def decode1(input, errors = 'strict'):
  481.                 return 42
  482.  
  483.             
  484.             def encode1(input, errors = 'strict'):
  485.                 return 42
  486.  
  487.             
  488.             def encode2(input, errors = 'strict'):
  489.                 return (42, 42)
  490.  
  491.             
  492.             def decode2(input, errors = 'strict'):
  493.                 return (42, 42)
  494.  
  495.             if encoding == 'test.unicode1':
  496.                 return (encode1, decode1, None, None)
  497.             elif encoding == 'test.unicode2':
  498.                 return (encode2, decode2, None, None)
  499.             else:
  500.                 return None
  501.  
  502.         codecs.register(search_function)
  503.         self.assertRaises(TypeError, 'hello'.decode, 'test.unicode1')
  504.         self.assertRaises(TypeError, unicode, 'hello', 'test.unicode2')
  505.         self.assertRaises(TypeError, u'hello'.encode, 'test.unicode1')
  506.         self.assertRaises(TypeError, u'hello'.encode, 'test.unicode2')
  507.         import imp as imp
  508.         self.assertRaises(ImportError, imp.find_module, 'non-existing module', [
  509.             u'non-existing dir'])
  510.         self.assertRaises(TypeError, u'hello'.encode, 42, 42, 42)
  511.         self.assertRaises(UnicodeError, int, u'\xc8\x80')
  512.  
  513.     
  514.     def test_codecs(self):
  515.         self.assertEqual(u'hello'.encode('ascii'), 'hello')
  516.         self.assertEqual(u'hello'.encode('utf-7'), 'hello')
  517.         self.assertEqual(u'hello'.encode('utf-8'), 'hello')
  518.         self.assertEqual(u'hello'.encode('utf8'), 'hello')
  519.         self.assertEqual(u'hello'.encode('utf-16-le'), 'h\x00e\x00l\x00l\x00o\x00')
  520.         self.assertEqual(u'hello'.encode('utf-16-be'), '\x00h\x00e\x00l\x00l\x00o')
  521.         self.assertEqual(u'hello'.encode('latin-1'), 'hello')
  522.         u = u''.join(map(unichr, xrange(1024)))
  523.         for encoding in ('utf-7', 'utf-8', 'utf-16', 'utf-16-le', 'utf-16-be', 'raw_unicode_escape', 'unicode_escape', 'unicode_internal'):
  524.             self.assertEqual(unicode(u.encode(encoding), encoding), u)
  525.         
  526.         u = u''.join(map(unichr, xrange(256)))
  527.         for encoding in ('latin-1',):
  528.             self.assertEqual(unicode(u.encode(encoding), encoding), u)
  529.         
  530.         u = u''.join(map(unichr, xrange(128)))
  531.         for encoding in ('ascii',):
  532.             self.assertEqual(unicode(u.encode(encoding), encoding), u)
  533.         
  534.         u = u'\xf0\x90\x80\x81\xf0\xa0\x80\x82\xf0\xb0\x80\x83\xf1\x80\x80\x84\xf1\x90\x80\x85'
  535.         for encoding in ('utf-8', 'utf-16', 'utf-16-le', 'utf-16-be', 'unicode_escape', 'unicode_internal'):
  536.             self.assertEqual(unicode(u.encode(encoding), encoding), u)
  537.         
  538.         u = u''.join(map(unichr, range(0, 55296) + range(57344, 65536)))
  539.         for encoding in ('utf-8',):
  540.             self.assertEqual(unicode(u.encode(encoding), encoding), u)
  541.         
  542.  
  543.     
  544.     def test_codecs_charmap(self):
  545.         s = ''.join(map(chr, xrange(128)))
  546.         for encoding in ('cp037', 'cp1026', 'cp437', 'cp500', 'cp737', 'cp775', 'cp850', 'cp852', 'cp855', 'cp860', 'cp861', 'cp862', 'cp863', 'cp865', 'cp866', 'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15', 'iso8859_2', 'iso8859_3', 'iso8859_4', 'iso8859_5', 'iso8859_6', 'iso8859_7', 'iso8859_9', 'koi8_r', 'latin_1', 'mac_cyrillic', 'mac_latin2', 'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255', 'cp1256', 'cp1257', 'cp1258', 'cp856', 'cp857', 'cp864', 'cp869', 'cp874', 'mac_greek', 'mac_iceland', 'mac_roman', 'mac_turkish', 'cp1006', 'iso8859_8'):
  547.             self.assertEqual(unicode(s, encoding).encode(encoding), s)
  548.         
  549.         s = ''.join(map(chr, xrange(128, 256)))
  550.         for encoding in ('cp037', 'cp1026', 'cp437', 'cp500', 'cp737', 'cp775', 'cp850', 'cp852', 'cp855', 'cp860', 'cp861', 'cp862', 'cp863', 'cp865', 'cp866', 'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15', 'iso8859_2', 'iso8859_4', 'iso8859_5', 'iso8859_9', 'koi8_r', 'latin_1', 'mac_cyrillic', 'mac_latin2'):
  551.             self.assertEqual(unicode(s, encoding).encode(encoding), s)
  552.         
  553.  
  554.     
  555.     def test_concatenation(self):
  556.         self.assertEqual(u'abcdef', u'abcdef')
  557.         self.assertEqual(u'abcdef', u'abcdef')
  558.         self.assertEqual(u'abcdef', u'abcdef')
  559.         self.assertEqual(u'abcdefghi', u'abcdefghi')
  560.         self.assertEqual(u'abcdefghi', u'abcdefghi')
  561.  
  562.     
  563.     def test_printing(self):
  564.         
  565.         class BitBucket:
  566.             
  567.             def write(self, text):
  568.                 pass
  569.  
  570.  
  571.         out = BitBucket()
  572.         print >>out, u'abc'
  573.         print >>out, u'abc', u'def'
  574.         print >>out, u'abc', 'def'
  575.         print >>out, 'abc', u'def'
  576.         print >>out, u'abc\n'
  577.         print >>out, u'abc\n',
  578.         print >>out, u'abc\n',
  579.         print >>out, u'def\n'
  580.         print >>out, u'def\n'
  581.  
  582.     
  583.     def test_ucs4(self):
  584.         if sys.maxunicode == 65535:
  585.             return None
  586.         
  587.         x = u'\xf4\x80\x80\x80'
  588.         y = x.encode('raw-unicode-escape').decode('raw-unicode-escape')
  589.         self.assertEqual(x, y)
  590.  
  591.  
  592.  
  593. def test_main():
  594.     test_support.run_unittest(UnicodeTest)
  595.  
  596. if __name__ == '__main__':
  597.     test_main()
  598.  
  599.